package cn.me.implement.threadpool.v4_0.util;

import cn.me.implement.threadpool.v4_0.ThreadPool4_0;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;

/**
 * <h3>线程池的工具类</h3>
 * 目前具备以下功能
 * <ul>
 *     <li>创建一个全是核心线程的线程池</li>
 *     <li>创建一个全是临时线程的线程池</li>
 *     <li>创建只有一个线程的线程池</li>
 * </ul>
 */
public class ThreadPoolUtil {

    /**
     * 创建一个全是核心线程的线程池
     *
     * @param poolSize 核心线程的数量
     * @return 一个全是核心线程的线程池
     */
    public static ThreadPool4_0 newFixedThreadPool(int poolSize) {
        return new ThreadPool4_0(poolSize, poolSize, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
    }

    /**
     * 创建一个全是核心线程的线程池
     *
     * @param poolSize 核心线程的数量
     * @param threadFactory 线程工厂
     * @return 一个全是核心线程的线程池
     */
    public static ThreadPool4_0 newFixedThreadPool(int poolSize, ThreadFactory threadFactory) {
        return new ThreadPool4_0(poolSize, poolSize, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), threadFactory);
    }

    /**
     * 创建一个全是临时线程的线程池
     *
     * @return 一个全是临时线程的线程池
     */
    public static ThreadPool4_0 newCachedThreadPool() {
        return new ThreadPool4_0(0, Integer.MAX_VALUE, 1, TimeUnit.SECONDS, new SynchronousQueue<>());
    }

    /**
     * 创建一个全是临时线程的线程池
     *
     * @param threadFactory 线程工厂
     * @return 一个全是临时线程的线程池
     */
    public static ThreadPool4_0 newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPool4_0(0, Integer.MAX_VALUE, 1, TimeUnit.SECONDS, new SynchronousQueue<>(), threadFactory);
    }

    /**
     * 创建只有一个线程的线程池
     *
     * @return 只有一个线程的线程池
     */
    public static ThreadPool4_0 newSingleThreadPool() {
        return new ThreadPool4_0(1, 1, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
    }

    /**
     * 创建只有一个线程的线程池
     *
     * @param threadFactory 线程工厂
     * @return 只有一个线程的线程池
     */
    public static ThreadPool4_0 newSingleThreadPool(ThreadFactory threadFactory) {
        return new ThreadPool4_0(1, 1, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), threadFactory);
    }
}
